 
 <body>
 
 <h1> Introduction</h1>
 <p>
 A Pairing library for a static size of elements.
 This library is Type safe ( crosses fingers  no I swear its type safe XD )
 The set of objects must be of all the same type( Now that I reflect if I knew how to reflect It would be way cool if they did not have to be of the same type)
 and the object must extend Pairable. The Pairable class allows for the caching of an objects partners(which could be an interface but I don`t trust you).
 </p>
 </p>
 Once a set of objects has been made Pairable and added into the system you can add a relationship to the pairing. The relationship is defined by attaching a calculation and a result block to the pairing.You create the
 relationship by passing the calculation to the create_relationship function of Pair.
  </p>
  <p>
 Before defining a calculation you have to create a class that implements the result interface. The result interface has no methods it is just a way of marking
 that your calculation is going to return this object as a result of being run/calculated. What this result class consists of is completely up to the implementation
 of your application.
 </p>
 <p>
 You then create your calculation by extending the abstract class calculation. You must implement the run method of calculation in your extended class. 
 The newly created extended calculation class will have direct access to the objects being worked on.  
 </p>
 <p>
 The result of your calculation should then be handed in the result class which will be passed back up and contain what ever its supposed to. There is a lot
 of freedom involved with this library and a lot of uses for it. It is important that you follow the flow of logic with it. In that manner it is even
 more important that I write better documentation for you then this short blurb and create the required Java docs ;)
 </p>
 <p>
 With this calculation result structure you can define relationships differently for each pairing. This gives you the freedom of allowing you to chose what alogorithm
 you want to use based on the given pairing situation. 
 </p>
 <p>
 In the most basic form this library facilitates creating relationships between sets of objects and defining what a relationship
 means.
 </p>
 

 
 
 </p>
 The simple pair class also has facilities for creating batch relationships. First you define a the Calculation class you wish
 to be applied across your pairs you then define the Result_block you would like to handle your return.(Both created Classes
 must be outer classes) You then pass a String representing the fully qualified path name of your classes to the appropriate
 SimplePairs function SimplePairs.batch_set_relaitonship("path.to.My_calculation","path.to.My_result_block"). From then on you can 
 run batch calculations and do batch returns. Do not forget that batch return will return an array of the type Result_block and that
 YOU MUST CAST EACH ELEMENT of the Result_block array individually. If you attempt to cast the entire array
 you will get a runtime ERROR  { My_result_block[] my_results =  (MY_result_block[])SimplePairs.batch_result() } === FAIL
 <p>
 
 </body>
 